package com.order.manager.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageInfo;
import com.github.pagehelper.page.PageMethod;
import com.order.manager.Model.*;
import com.order.manager.Model.other.MenuCount;
import com.order.manager.Model.other.OrderForSender;
import com.order.manager.mapper.OrderInfoMapper;
import com.order.manager.service.OrderInfoService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * @author 24862
 * @description 针对表【order_info】的数据库操作Service实现
 * @createDate 2024-04-08 16:43:01
 */
@Service
public class OrderInfoServiceImpl extends ServiceImpl<OrderInfoMapper, OrderInfo> implements OrderInfoService {

    @Resource
    OrderInfoMapper orderInfoMapper;

    @Resource
    MenuInfoServiceImpl menuInfoService;

    @Resource
    ShopInfoServiceImpl shopInfoService;

    @Resource
    SenderInfoServiceImpl senderInfoService;

    @Resource
    UserInfoServiceImpl userInfoService;

    @Resource
    UserAddressServiceImpl userAddressService;

    @Resource
    OrderMenuInfoServiceImpl orderMenuInfoService;

    @Resource
    OrderSendInfoServiceImpl orderSendInfoService;

    /**
     * 配送员查询待接单列表（分页）
     *
     * @param page 页码
     * @param item 每页数量
     * @return 分页包装的配送订单信息（包含订单详情、商品信息、用户信息等）
     *
     * @implNote 核心逻辑：
     * 1. 查询所有已支付订单
     * 2. 过滤掉已分配配送员（state=0或1）的订单
     * 3. 组装订单详情、用户地址、商品列表、店铺名称等信息
     * 4. 封装为OrderForSender对象并返回分页结果
     */
    @Override
    public PageInfo<OrderForSender> querySenderFindList(int page, int item) {
        // 启动分页
        PageMethod.startPage(page, item);
        List<OrderForSender> orderForSenderList = new ArrayList<>();
        // 查询所有已支付订单（applyState=1）
        List<OrderInfo> orderInfoList = orderInfoMapper.queryIsApplyList();

        for (OrderInfo orderInfo : orderInfoList) {
            // 过滤已分配配送员的订单（state=0或1表示已接单/配送中）
            if (orderSendInfoService.count(new QueryWrapper<OrderSendInfo>()
                    .eq("order_id", orderInfo.getOrderId())
                    .eq("state", 0)) != 0 ||
                    orderSendInfoService.count(new QueryWrapper<OrderSendInfo>()
                            .eq("order_id", orderInfo.getOrderId())
                            .eq("state", 1)) != 0) {
                continue;
            }

            OrderForSender order = new OrderForSender();
            order.setInputTime(orderInfo.getInputTime());

            // 处理用户地址（避免空指针）
            if (userAddressService.count(new QueryWrapper<UserAddress>()
                    .eq("address_id", orderInfoMapper.selectById(orderInfo.getOrderId()).getAddressId())) == 0 ||
                    userAddressService.getById(orderInfoMapper.selectById(orderInfo.getOrderId()).getAddressId()).getAddress() == null) {
                order.setAddress("");
            } else {
                order.setAddress(userAddressService.getById(orderInfoMapper.selectById(orderInfo.getOrderId()).getAddressId()).getAddress());
            }

            // 组装订单商品列表
            List<OrderMenuInfo> orderMenuInfos = orderMenuInfoService.list(new QueryWrapper<OrderMenuInfo>()
                    .eq("order_id", orderInfo.getOrderId()));
            List<MenuCount> counts = new ArrayList<>();
            for (OrderMenuInfo orderMenuInfo : orderMenuInfos) {
                MenuCount menuCount = new MenuCount();
                menuCount.setCount(orderMenuInfo.getCount());
                menuCount.setMenuId(orderMenuInfo.getMenuId());
                menuCount.setMenuName(menuInfoService.getById(orderMenuInfo.getMenuId()).getMenuName());
                menuCount.setMenuPicture(menuInfoService.getById(orderMenuInfo.getMenuId()).getMenuPicture());
                menuCount.setMenuPrice(menuInfoService.getById(orderMenuInfo.getMenuId()).getMenuPrice());
                counts.add(menuCount);
            }

            // 填充订单基础信息
            order.setDemo(orderInfo.getDemo());
            order.setOrderId(orderInfo.getOrderId());
            order.setMenuName(counts);
            order.setShopName(shopInfoService.getById(orderInfo.getShopId()).getShopName());
            order.setState("待接单");
            order.setUserId(orderInfo.getUserId());
            order.setUsername(userInfoService.getById(orderInfo.getUserId()).getUsername());

            // 处理用户电话（避免空指针）
            if (userInfoService.getById(orderInfo.getUserId()).getPhone() == null) {
                order.setUserPhone("");
            } else {
                order.setUserPhone(userInfoService.getById(orderInfo.getUserId()).getPhone());
            }

            orderForSenderList.add(order);
        }
        return new PageInfo<>(orderForSenderList);
    }

    /**
     * 配送员查询自己的接单列表（分页）
     *
     * @param page     页码
     * @param item     每页数量
     * @param senderId 配送员ID
     * @return 分页包装的配送员个人订单列表（包含订单状态、用户信息、配送信息等）
     *
     * @implNote 核心逻辑：
     * 1. 根据配送员ID查询其所有配送记录
     * 2. 遍历配送记录，查询对应的订单信息
     * 3. 组装订单详情、用户地址、商品列表、配送状态等信息
     * 4. 封装为OrderForSender对象并返回分页结果
     */
    @Override
    public PageInfo<OrderForSender> queryByMyself(int page, int item, String senderId) {
        // 查询配送员的所有配送记录
        List<OrderSendInfo> orderSendInfos = orderSendInfoService.list(new QueryWrapper<OrderSendInfo>()
                .eq("sender_id", senderId));
        List<OrderForSender> orderForSenders = new ArrayList<>();

        for (OrderSendInfo orderSendInfo : orderSendInfos) {
            OrderForSender orderForSender = new OrderForSender();
            // 根据订单ID查询订单基础信息
            OrderInfo order = orderInfoMapper.selectOne(new QueryWrapper<OrderInfo>()
                    .eq("order_id", orderSendInfo.getOrderId()));
            if (order == null) continue;

            orderForSender.setOrderId(order.getOrderId());
            // 根据配送状态码转换为中文状态描述
            orderForSender.setState(orderSendInfo.getState() == 0 ? "正在配送" :
                    orderSendInfo.getState() == 1 ? "已送达" :
                            orderSendInfo.getState() == -1 ? "骑手已退单，待其他骑手接单" : "未知");

            // 处理用户地址（避免空指针）
            if (userAddressService.count(new QueryWrapper<UserAddress>()
                    .eq("address_id", orderInfoMapper.selectById(orderSendInfo.getOrderId()).getAddressId())) == 0 ||
                    userAddressService.getById(orderInfoMapper.selectById(orderSendInfo.getOrderId()).getAddressId()).getAddress() == null) {
                orderForSender.setAddress("");
            } else {
                orderForSender.setAddress(userAddressService.getById(orderInfoMapper.selectById(orderSendInfo.getOrderId()).getAddressId()).getAddress());
            }

            // 组装订单商品列表
            List<OrderMenuInfo> orderMenuInfos = orderMenuInfoService.list(new QueryWrapper<OrderMenuInfo>()
                    .eq("order_id", orderSendInfo.getOrderId()));
            List<MenuCount> menuCounts = new ArrayList<>();
            for (OrderMenuInfo orderMenuInfo : orderMenuInfos) {
                MenuCount menuCount = new MenuCount();
                menuCount.setMenuName(menuInfoService.getById(orderMenuInfo.getMenuId()).getMenuName());
                menuCount.setMenuPrice(menuInfoService.getById(orderMenuInfo.getMenuId()).getMenuPrice());
                menuCount.setCount(orderMenuInfo.getCount());
                menuCount.setMenuPicture(menuInfoService.getById(orderMenuInfo.getMenuId()).getMenuPicture());
                menuCount.setMenuId(orderMenuInfo.getMenuId());
                menuCounts.add(menuCount);
            }

            // 填充订单详情信息
            orderForSender.setMenuName(menuCounts);
            orderForSender.setShopName(shopInfoService.getById(order.getShopId()).getShopName());
            orderForSender.setInputTime(order.getInputTime());
            orderForSender.setUserId(order.getUserId());
            orderForSender.setUsername(userInfoService.getById(order.getUserId()).getName());
            orderForSender.setSenderName(userInfoService.getById(senderInfoService.getById(senderId).getUserId()).getName());
            orderForSender.setSenderId(orderSendInfo.getSenderId());

            // 处理用户电话（避免空指针）
            if (userInfoService.count(new QueryWrapper<UserInfo>().eq("user_id", order.getUserId())) == 0 ||
                    userInfoService.getById(order.getUserId()).getPhone() == null) {
                orderForSender.setUserPhone("未知");
            } else {
                orderForSender.setUserPhone(userInfoService.getById(order.getUserId()).getPhone());
            }

            // 处理配送员电话（避免空指针）
            if (userInfoService.count(new QueryWrapper<UserInfo>().eq("user_id", orderSendInfo.getSenderId())) == 0 ||
                    userInfoService.getById(orderSendInfo.getSenderId()).getPhone() == null) {
                orderForSender.setSenderPhone("未知");
            } else {
                orderForSender.setSenderPhone(userInfoService.getById(orderSendInfo.getSenderId()).getPhone());
            }

            orderForSender.setDemo(order.getDemo() == null ? "" : order.getDemo());
            orderForSenders.add(orderForSender);
        }
        return new PageInfo<>(orderForSenders);
    }

    /**
     * 店铺查询订单列表（分页）
     *
     * @param page    页码
     * @param item    每页数量
     * @param shopId  店铺ID
     * @return 分页包装的店铺订单列表（包含订单详情、商品信息、用户信息等）
     *
     * @implNote 核心逻辑：
     * 1. 根据店铺ID查询所有订单
     * 2. 过滤掉未支付订单（applyState=0）
     * 3. 组装订单详情、用户地址、商品列表、订单类型（堂食/外卖）等信息
     * 4. 对于外卖订单，查询配送员信息及配送状态
     * 5. 封装为OrderForSender对象并返回分页结果
     */
    @Override
    //PageInfo查询结果分页展示
    public PageInfo<OrderForSender> queryByShop(int page, int item, String shopId) {
        // 启动分页
        PageMethod.startPage(page, item);
        // 查询店铺的所有订单
        List<OrderInfo> orderInfoList = orderInfoMapper.selectList(new QueryWrapper<OrderInfo>()
                //对应 SQL：WHERE shop_id = shop_id
                .eq("shop_id", shopId));
        List<OrderForSender> orderForSenders = new ArrayList<>();

        for (OrderInfo orderInfo : orderInfoList) {
            // 过滤未支付订单（applyState=0）
            if (orderInfo.getApplyState() == 0) {
                continue;
            }

            OrderForSender order = new OrderForSender();
            order.setInputTime(orderInfo.getInputTime());

            // 处理用户地址（避免空指针）
            // 校验用户地址有效性并设置订单地址
            // 1. 查询address_id等于当前订单address_id的记录数，判断地址是否存在
            // 2. 获取地址对象并检查address字段是否为null，确保地址内容有效
            // 3. 任一条件不满足时设置订单地址为空字符串，否则设置为实际地址
            if (userAddressService.count(new QueryWrapper<UserAddress>()
                    // 对应SQL：WHERE address_id = 当前订单的address_id
                    .eq("address_id", orderInfoMapper.selectById(orderInfo.getOrderId()).getAddressId())) == 0 ||
                    userAddressService.getById(orderInfoMapper.selectById(orderInfo.getOrderId()).getAddressId()).getAddress() == null) {
                // 地址不存在或地址内容为空时的默认处理
                order.setAddress("");
            } else {
                // 地址存在且有效时设置实际地址内容
                order.setAddress(userAddressService.getById(orderInfoMapper.selectById(orderInfo.getOrderId()).getAddressId()).getAddress());
            }
            // 查询当前订单下的所有菜品信息（OrderMenuInfo记录）
            List<OrderMenuInfo> orderMenuInfos = orderMenuInfoService.list(
                    new QueryWrapper<OrderMenuInfo>().eq("order_id", orderInfo.getOrderId())
            );
                // 用于存储转换后的菜品统计信息（包含菜品详情）
            List<MenuCount> counts = new ArrayList<>();
                // 遍历订单中的每条菜品记录，转换为带完整信息的MenuCount对象
            for (OrderMenuInfo orderMenuInfo : orderMenuInfos) {
                // 创建菜品统计对象
                MenuCount menuCount = new MenuCount();
                // 设置订单中该菜品的数量
                menuCount.setCount(orderMenuInfo.getCount());
                // 设置菜品ID
                menuCount.setMenuId(orderMenuInfo.getMenuId());
                // 通过菜品ID查询菜品名称并设置（存在N+1查询问题）
                menuCount.setMenuName(menuInfoService.getById(orderMenuInfo.getMenuId()).getMenuName());
                // 通过菜品ID查询菜品图片并设置（存在N+1查询问题）
                menuCount.setMenuPicture(menuInfoService.getById(orderMenuInfo.getMenuId()).getMenuPicture());
                // 通过菜品ID查询菜品价格并设置（存在N+1查询问题）
                menuCount.setMenuPrice(menuInfoService.getById(orderMenuInfo.getMenuId()).getMenuPrice());
                // 将转换后的菜品统计对象添加到结果列表
                counts.add(menuCount);
            }

            // 填充订单基础信息
            order.setMoney(orderInfo.getMoney().toString());
            // 根据类型码转换为中文类型描述
            order.setType(orderInfo.getType() == 1 ? "堂食" : "外卖");
            // 根据支付状态码转换为中文描述（1=已支付，其他值=已退款）
            order.setApplyState(orderInfo.getApplyState() == 1 ? "已支付" : "已退款");
            // 设置订单备注信息，若备注为空则设为空字符串（避免前端显示null）
            order.setDemo(orderInfo.getDemo() == null ? "" : orderInfo.getDemo());
            // 设置订单ID
            order.setOrderId(orderInfo.getOrderId());
            // 设置订单包含的菜品列表（已在前面处理为带完整信息的MenuCount对象）
            order.setMenuName(counts);
            // 通过店铺ID查询并设置店铺名称
            order.setShopName(shopInfoService.getById(orderInfo.getShopId()).getShopName());
            // 设置下单用户ID
            order.setUserId(orderInfo.getUserId());
            // 处理用户电话（避免空指针）
            // 校验用户是否存在并处理用户电话（若用户不存在或电话为空则设为空字符串）
            if (userInfoService.count(new QueryWrapper<UserInfo>().eq("user_id", orderInfo.getUserId())) == 0 ||
                    userInfoService.getById(orderInfo.getUserId()).getPhone() == null) {
                // 用户不存在或电话为空时，设置订单的用户电话为空字符串
                order.setUserPhone("");
            }
                // 从用户信息中获取用户名并设置到订单对象
            order.setUsername(userInfoService.getById(orderInfo.getUserId()).getUsername());

                // 判断订单类型是否为外卖订单（type=2表示外卖订单）
            if (orderInfo.getType() == 2) {
                // 初始化外卖订单的配送信息（默认状态为待接单）
                order.setSenderName("");        // 初始化配送员姓名为空
                order.setSenderPhone("");       // 初始化配送员电话为空
                order.setState("待骑手接单");    // 初始化订单状态为待接单
                order.setSenderId("");          // 初始化配送员ID为空

                // 查询订单是否已分配配送员（通过order_send_info表中是否存在该订单记录判断）
                if (orderSendInfoService.count(new QueryWrapper<OrderSendInfo>()
                        .eq("order_id", orderInfo.getOrderId())) != 0) {
                    // 获取该订单的配送员信息
                    SenderInfo senderInfo = senderInfoService.getOne(new QueryWrapper<SenderInfo>()
                            .eq("sender_id", orderSendInfoService.getOne(new QueryWrapper<OrderSendInfo>()
                                    .eq("order_id", orderInfo.getOrderId())).getSenderId()));
                    // 设置配送员ID到订单对象
                    order.setSenderId(senderInfo.getSenderId());
                    // 通过配送员关联的用户ID查询用户姓名并设置到订单对象
                    order.setSenderName(userInfoService.getOne(new QueryWrapper<UserInfo>()
                            .eq("user_id", senderInfo.getUserId())).getName());

                    // 处理配送员电话（避免空指针异常）
                    if (userInfoService.count(new QueryWrapper<UserInfo>().eq("user_id", senderInfo.getUserId())) != 0 ||
                            userInfoService.getOne(new QueryWrapper<UserInfo>().eq("user_id", senderInfo.getUserId())).getPhone() != null) {
                        // 设置配送员电话到订单对象
                        order.setSenderPhone(userInfoService.getOne(new QueryWrapper<UserInfo>()
                                .eq("user_id", senderInfo.getUserId())).getPhone());
                    }
                }

                // 更新订单的配送状态（根据order_send_info表中的state字段转换为中文描述）
                if (orderSendInfoService.count(new QueryWrapper<OrderSendInfo>()
                        .eq("order_id", orderInfo.getOrderId())) != 0) {
                    // 根据配送状态码设置订单状态描述（0=配送中，1=已送达，其他=未知）
                    order.setState(orderSendInfoService.getOne(new QueryWrapper<OrderSendInfo>()
                            .eq("order_id", orderInfo.getOrderId())).getState() == 1 ? "已送达" :
                            orderSendInfoService.getOne(new QueryWrapper<OrderSendInfo>()
                                    .eq("order_id", orderInfo.getOrderId())).getState() == 0 ? "正在配送中" : "未知");
                }
            }

            // 补充用户姓名（覆盖之前可能设置的用户名，确保一致性）
            order.setUsername(userInfoService.getById(orderInfo.getUserId()).getName());
                // 最终处理用户电话（确保不会为null，统一未知状态的显示）
            if (userInfoService.getById(orderInfo.getUserId()).getPhone() == null) {
                // 用户电话为空时设置为"未知"
                order.setUserPhone("未知");
            } else {
                // 用户电话存在时设置实际值
                order.setUserPhone(userInfoService.getById(orderInfo.getUserId()).getPhone());
            }

            // 将处理完成的订单信息添加到分页结果列表
            orderForSenders.add(order);
        }
        // new PageInfo<>(orderForSenders) 会自动：
        //获取当前页数据（orderForSenders）
        //计算总记录数（通过执行 SELECT COUNT(*)）
        //计算总页数、当前页码等信息
        return new PageInfo<>(orderForSenders);
    }
}